/**
 * ECS 系统配置示例（配置驱动注册）
 * 
 * 适用场景：
 * - 大型项目（100+ 系统）
 * - 需要动态开关系统
 * - 需要调整系统优先级
 * - 需要按环境配置系统
 * 
 * @author AI Assistant
 * @date 2025-12-02
 */

import type { FixedUpdateManager } from "../FixedUpdateManager";
import { ecs } from "../../../core/ecs/ECS";
import { Log } from "../../../core/logger/LoggerGlobal";

// ========== 系统配置接口 ==========

export interface SystemConfig {
    /** 系统名称（唯一标识） */
    name: string;
    
    /** 是否启用 */
    enabled: boolean;
    
    /** 优先级（数字越小越先执行） */
    priority?: number;
    
    /** 所属模块 */
    module: string;
    
    /** 描述 */
    description?: string;
    
    /** 开发环境专用 */
    devOnly?: boolean;
    
    /** 生产环境专用 */
    prodOnly?: boolean;
}

// ========== 系统配置定义 ==========

/**
 * 逻辑系统配置表
 */
export const LOGIC_SYSTEMS_CONFIG: SystemConfig[] = [
    // ========== 输入模块（优先级 0-99）==========
    {
        name: 'Input',
        enabled: true,
        priority: 10,
        module: 'input',
        description: '输入处理系统'
    },
    {
        name: 'InputBuffer',
        enabled: true,
        priority: 20,
        module: 'input',
        description: '输入缓冲系统'
    },
    
    // ========== 移动模块（优先级 100-199）==========
    {
        name: 'Movement',
        enabled: true,
        priority: 100,
        module: 'movement',
        description: '移动逻辑系统'
    },
    {
        name: 'Jump',
        enabled: true,
        priority: 110,
        module: 'movement',
        description: '跳跃逻辑系统'
    },
    {
        name: 'Dash',
        enabled: true,
        priority: 120,
        module: 'movement',
        description: '冲刺逻辑系统'
    },
    {
        name: 'Climb',
        enabled: false,  // ❌ 暂未实现，禁用
        priority: 130,
        module: 'movement',
        description: '攀爬逻辑系统'
    },
    
    // ========== 物理模块（优先级 200-299）==========
    {
        name: 'Physics',
        enabled: true,
        priority: 200,
        module: 'physics',
        description: '物理模拟系统'
    },
    {
        name: 'Collision',
        enabled: true,
        priority: 210,
        module: 'physics',
        description: '碰撞检测系统'
    },
    
    // ========== 战斗模块（优先级 300-399）==========
    {
        name: 'Combat',
        enabled: true,
        priority: 300,
        module: 'combat',
        description: '战斗逻辑系统'
    },
    {
        name: 'Damage',
        enabled: true,
        priority: 310,
        module: 'combat',
        description: '伤害计算系统'
    },
    {
        name: 'Skill',
        enabled: true,
        priority: 320,
        module: 'combat',
        description: '技能系统'
    },
    {
        name: 'Buff',
        enabled: true,
        priority: 330,
        module: 'combat',
        description: 'Buff 系统'
    },
    
    // ========== AI 模块（优先级 400-499）==========
    {
        name: 'AI',
        enabled: true,
        priority: 400,
        module: 'ai',
        description: 'AI 逻辑系统'
    },
    {
        name: 'BehaviorTree',
        enabled: true,
        priority: 410,
        module: 'ai',
        description: '行为树系统'
    },
    {
        name: 'Pathfinding',
        enabled: true,
        priority: 420,
        module: 'ai',
        description: '寻路系统'
    },
    
    // ========== 调试模块（优先级 900-999）==========
    {
        name: 'Debug',
        enabled: true,
        priority: 900,
        module: 'debug',
        description: '调试系统',
        devOnly: true  // ✅ 仅开发环境
    },
    {
        name: 'DebugDraw',
        enabled: true,
        priority: 910,
        module: 'debug',
        description: '调试绘制系统',
        devOnly: true
    }
];

// ========== 系统注册表（映射）==========

/**
 * 系统映射表
 * 
 * 注意：这里需要导入所有系统实例
 */
const SYSTEM_MAP = new Map<string, ecs.ComblockSystem>([
    // ['Input', inputSystem],
    // ['Movement', movementLogicSystem],
    // ['Jump', jumpLogicSystem],
    // ['Dash', dashLogicSystem],
    // ['Physics', physicsLogicSystem],
    // ['Collision', collisionSystem],
    // ['Combat', combatLogicSystem],
    // ['Damage', damageLogicSystem],
    // ['Skill', skillSystem],
    // ['Buff', buffSystem],
    // ['AI', aiLogicSystem],
    // ['BehaviorTree', behaviorTreeSystem],
    // ['Pathfinding', pathfindingSystem],
    // ['Debug', debugSystem],
    // ['DebugDraw', debugDrawSystem]
    
    // ✅ 添加更多系统映射...
]);

// ========== 配置驱动注册函数 ==========

/**
 * 配置驱动注册逻辑系统
 * 
 * @param manager 固定更新管理器
 * @param customConfig 自定义配置（可选，用于覆盖默认配置）
 */
export function registerLogicSystemsWithConfig(
    manager: FixedUpdateManager,
    customConfig?: SystemConfig[]
): void {
    const config = customConfig || LOGIC_SYSTEMS_CONFIG;
    
    // ✅ 过滤和排序
    const systemsToRegister = config
        .filter(cfg => {
            // 1. 必须启用
            if (!cfg.enabled) {
                Log.ecs.debug(`系统已禁用: ${cfg.name}`);
                return false;
            }
            
            // 2. 检查环境
            const isDev = DEBUG;  // 假设有全局 DEBUG 变量
            
            if (cfg.devOnly && !isDev) {
                Log.ecs.debug(`系统仅在开发环境可用: ${cfg.name}`);
                return false;
            }
            
            if (cfg.prodOnly && isDev) {
                Log.ecs.debug(`系统仅在生产环境可用: ${cfg.name}`);
                return false;
            }
            
            return true;
        })
        .sort((a, b) => (a.priority || 0) - (b.priority || 0));  // 按优先级排序
    
    Log.styled('⚙️  注册逻辑系统（配置驱动）', 'medium');
    Log.ecs.info(`总配置: ${config.length} 个，启用: ${systemsToRegister.length} 个`);
    
    // ✅ 按配置注册系统
    let registeredCount = 0;
    const failedSystems: string[] = [];
    
    for (const cfg of systemsToRegister) {
        const system = SYSTEM_MAP.get(cfg.name);
        
        if (system) {
            manager.registerLogicSystem(system);
            registeredCount++;
            
            Log.ecs.debug(
                `✓ ${cfg.name.padEnd(20)} | 优先级: ${String(cfg.priority || 0).padStart(3)} | 模块: ${cfg.module}`
            );
        } else {
            failedSystems.push(cfg.name);
            Log.ecs.warn(`✗ 系统未找到: ${cfg.name}`);
        }
    }
    
    // ✅ 打印统计信息
    Log.styled('━'.repeat(60), 'separator');
    Log.ecs.info(`成功注册: ${registeredCount}/${systemsToRegister.length} 个系统`);
    
    if (failedSystems.length > 0) {
        Log.ecs.warn(`未找到系统: ${failedSystems.join(', ')}`);
    }
    
    // ✅ 按模块统计
    const moduleStats = new Map<string, number>();
    for (const cfg of systemsToRegister) {
        const count = moduleStats.get(cfg.module) || 0;
        moduleStats.set(cfg.module, count + 1);
    }
    
    Log.ecs.info('按模块统计:');
    for (const [module, count] of moduleStats) {
        Log.ecs.info(`  ${module.padEnd(15)}: ${count} 个系统`);
    }
    
    Log.styled('━'.repeat(60), 'separator');
}

// ========== 工具函数 ==========

/**
 * 根据模块获取系统配置
 */
export function getSystemsByModule(module: string): SystemConfig[] {
    return LOGIC_SYSTEMS_CONFIG.filter(cfg => cfg.module === module);
}

/**
 * 根据名称获取系统配置
 */
export function getSystemConfig(name: string): SystemConfig | undefined {
    return LOGIC_SYSTEMS_CONFIG.find(cfg => cfg.name === name);
}

/**
 * 启用系统
 */
export function enableSystem(name: string): boolean {
    const config = getSystemConfig(name);
    if (config) {
        config.enabled = true;
        Log.ecs.info(`系统已启用: ${name}`);
        return true;
    }
    Log.ecs.warn(`系统未找到: ${name}`);
    return false;
}

/**
 * 禁用系统
 */
export function disableSystem(name: string): boolean {
    const config = getSystemConfig(name);
    if (config) {
        config.enabled = false;
        Log.ecs.info(`系统已禁用: ${name}`);
        return true;
    }
    Log.ecs.warn(`系统未找到: ${name}`);
    return false;
}

/**
 * 启用模块
 */
export function enableModule(module: string): number {
    const systems = getSystemsByModule(module);
    let count = 0;
    
    for (const system of systems) {
        system.enabled = true;
        count++;
    }
    
    Log.ecs.info(`模块 ${module} 已启用: ${count} 个系统`);
    return count;
}

/**
 * 禁用模块
 */
export function disableModule(module: string): number {
    const systems = getSystemsByModule(module);
    let count = 0;
    
    for (const system of systems) {
        system.enabled = false;
        count++;
    }
    
    Log.ecs.info(`模块 ${module} 已禁用: ${count} 个系统`);
    return count;
}

// ========== 使用示例 ==========

/**
 * 示例 1：基本使用
 * 
 * ```typescript
 * import { registerLogicSystemsWithConfig } from './logic/systemConfig.example';
 * 
 * // 使用默认配置
 * registerLogicSystemsWithConfig(fixedUpdateManager);
 * ```
 */

/**
 * 示例 2：自定义配置
 * 
 * ```typescript
 * const customConfig: SystemConfig[] = [
 *     { name: 'Movement', enabled: true, priority: 100, module: 'movement' },
 *     { name: 'Physics', enabled: false, priority: 200, module: 'physics' }
 * ];
 * 
 * registerLogicSystemsWithConfig(fixedUpdateManager, customConfig);
 * ```
 */

/**
 * 示例 3：动态控制
 * 
 * ```typescript
 * // 禁用某个系统
 * disableSystem('AI');
 * 
 * // 启用某个系统
 * enableSystem('Debug');
 * 
 * // 禁用整个模块
 * disableModule('debug');
 * 
 * // 重新注册
 * registerLogicSystemsWithConfig(fixedUpdateManager);
 * ```
 */

/**
 * 示例 4：按环境配置
 * 
 * ```typescript
 * // 开发环境：启用所有系统（包括调试）
 * if (DEBUG) {
 *     enableModule('debug');
 * }
 * 
 * // 生产环境：禁用调试系统
 * if (!DEBUG) {
 *     disableModule('debug');
 * }
 * 
 * registerLogicSystemsWithConfig(fixedUpdateManager);
 * ```
 */

